"""用户引导和状态管理服务"""
from typing import Dict, Any, Optional
from datetime import datetime
from app.core.database import RedisClient


class UserOnboardingService:
    """用户引导服务"""
    
    def __init__(self):
        # 无论Redis是否可用，都初始化内存存储（作为备份）
        self._memory_storage = {}
        self.redis = None
        try:
            # 尝试连接Redis，但设置超时避免阻塞
            redis_client = RedisClient.get_client()
            # 快速ping测试（如果Redis不可用会快速失败）
            redis_client.ping()
            self.redis = redis_client
        except Exception as e:
            print(f"⚠️ [用户状态] Redis连接失败，将使用文件存储和内存存储: {e}")
            self.redis = None
    
    def get_user_status(self, user_id: str) -> Dict[str, Any]:
        """
        获取用户状态
        
        Returns:
            {
                "has_completed_test": bool,  # 是否完成初始测试
                "has_plan": bool,  # 是否有学习计划
                "plan_id": Optional[str],  # 计划ID
                "current_stage": str,  # 当前阶段: "first_visit", "test_completed", "plan_created", "learning"
            }
        """
        has_completed_test = False
        has_plan = False
        plan_id = None
        
        if self.redis:
            try:
                # 检查是否完成初始测试（快速操作，不阻塞）
                test_key = f"user_test:{user_id}"
                has_completed_test = bool(self.redis.exists(test_key))
                
                # 检查是否有激活的计划（快速操作，不阻塞）
                active_plan_key = f"active_plan:{user_id}"
                plan_id = self.redis.get(active_plan_key)
                if plan_id:
                    if isinstance(plan_id, bytes):
                        plan_id = plan_id.decode('utf-8')
                    has_plan = True
                    print(f"✅ [用户状态] 从Redis获取到激活计划: {plan_id}")
            except Exception as e:
                print(f"⚠️ [用户状态] Redis操作失败: {e}，将尝试文件存储")
                # Redis失败时，重置为None，避免后续重试
                self.redis = None
        
        # 如果Redis没有数据，尝试从文件存储读取（快速操作，不阻塞）
        if not has_plan or not has_completed_test:
            try:
                from app.services.file_storage_service import file_storage_service
                
                if not has_completed_test:
                    test_key = f"user_test:{user_id}"
                    if file_storage_service.exists(test_key):
                        has_completed_test = True
                        print(f"✅ [用户状态] 从文件存储获取到测试完成标记")
                
                if not has_plan:
                    active_plan_key = f"active_plan:{user_id}"
                    file_plan_id = file_storage_service.get(active_plan_key)
                    if file_plan_id:
                        plan_id = file_plan_id
                        has_plan = True
                        print(f"✅ [用户状态] 从文件存储获取到激活计划: {plan_id}")
            except Exception as e:
                print(f"⚠️ [用户状态] 文件存储读取失败（不影响返回）: {e}")
                # 文件存储失败不影响返回，继续使用内存存储
        
        # 无论Redis是否可用，都检查内存存储（作为最后的备份）
        if not hasattr(self, '_memory_storage'):
            self._memory_storage = {}
        memory_test_completed = self._memory_storage.get(f"test_completed:{user_id}", False)
        memory_plan_id = self._memory_storage.get(f"active_plan:{user_id}")
        
        # 如果Redis和文件存储都没有数据，使用内存存储的数据
        if not has_completed_test and memory_test_completed:
            has_completed_test = True
            print(f"✅ [用户状态] 从内存获取到测试完成标记")
        if not has_plan and memory_plan_id:
            plan_id = memory_plan_id
            has_plan = True
            print(f"✅ [用户状态] 从内存获取到激活计划: {plan_id}")
        
        # 确定当前阶段
        if not has_completed_test:
            current_stage = "first_visit"
        elif not has_plan:
            current_stage = "test_completed"
        else:
            current_stage = "learning"  # 有计划就进入学习阶段
        
        print(f"🔍 [用户状态] 用户 {user_id} 状态: has_test={has_completed_test}, has_plan={has_plan}, plan_id={plan_id}, stage={current_stage}")
        
        return {
            "user_id": user_id,
            "has_completed_test": has_completed_test,
            "has_plan": has_plan,
            "plan_id": plan_id,
            "current_stage": current_stage
        }
    
    def mark_test_completed(self, user_id: str, test_result: Dict[str, Any]):
        """标记测试完成"""
        import json
        test_data = {
            "completed_at": datetime.now().isoformat(),
            "test_result": test_result
        }
        
        # 保存到Redis（如果可用）
        saved_to_redis = False
        if self.redis:
            try:
                test_key = f"user_test:{user_id}"
                self.redis.setex(
                    test_key,
                    86400 * 365,  # 保存1年
                    json.dumps(test_data, ensure_ascii=False)
                )
                saved_to_redis = True
                print(f"✅ [标记测试完成] 已保存到Redis: user_test:{user_id}")
            except Exception as e:
                print(f"⚠️ Redis操作失败: {e}，将使用文件存储")
        
        # 如果Redis不可用，使用文件存储
        if not saved_to_redis:
            try:
                from app.services.file_storage_service import file_storage_service
                test_key = f"user_test:{user_id}"
                file_storage_service.set(test_key, json.dumps(test_data, ensure_ascii=False), expire=86400 * 365)
                print(f"✅ [文件存储] 测试完成标记已保存到文件: user_test:{user_id}")
            except Exception as e2:
                print(f"⚠️ 文件存储失败: {e2}")
        
        # 无论Redis是否可用，都保存到内存存储（作为最后的备份）
        if not hasattr(self, '_memory_storage'):
            self._memory_storage = {}
        self._memory_storage[f"test_completed:{user_id}"] = True
        self._memory_storage[f"test_result:{user_id}"] = test_data
        print(f"✅ [内存存储] 测试完成标记已保存到内存: user_test:{user_id}")
    
    def get_test_result(self, user_id: str) -> Optional[Dict[str, Any]]:
        """获取测试结果"""
        # 优先从Redis读取
        if self.redis:
            try:
                test_key = f"user_test:{user_id}"
                if self.redis.exists(test_key):
                    import json
                    data = self.redis.get(test_key)
                    if isinstance(data, bytes):
                        data = data.decode('utf-8')
                    return json.loads(data)
            except Exception as e:
                print(f"⚠️ Redis读取失败: {e}")
        
        # 如果Redis没有，尝试从文件存储读取
        try:
            from app.services.file_storage_service import file_storage_service
            test_key = f"user_test:{user_id}"
            data = file_storage_service.get(test_key)
            if data:
                import json
                if isinstance(data, str):
                    return json.loads(data)
                return data
        except Exception as e:
            print(f"⚠️ 文件存储读取失败: {e}")
        
        # 最后尝试内存存储
        if not hasattr(self, '_memory_storage'):
            self._memory_storage = {}
        return self._memory_storage.get(f"test_result:{user_id}")


user_onboarding_service = UserOnboardingService()

